

package com.mjsoftking.palettelib.utils;

import android.text.TextUtils;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * <p>
 * ListUtils
 * </p>
 * <p>
 * 列表处理工具
 * </p>
 */
public class ListUtils {


    public static <T> boolean isListEmpty(List<T> list) {
        if (list == null || list.isEmpty()) {
            return true;
        }
        return false;
    }

    public static <T> List<T> add(List<T> list, T o) {
        if (isListEmpty(list)) {
            list = new ArrayList<T>();
        }
        if (o != null) {
            list.add(o);
        }
        return list;
    }

    /**
     * 获取列表下全部数据，某字符串属性使用特定的拼接字符的拼接结果
     *
     * @param list          列表数据
     * @param interpolation 拼接字符
     * @param iJoin         指定拼接字符串时使用的属性
     * @param <E>           对泛型列表使用
     * @return 最终的拼接结果，如果属性都为空，则返回空字符串
     */
    public static <E> String join(List<E> list, String interpolation, IJoin<E> iJoin) {
        if (list == null || list.size() == 0) return "";
        StringBuilder content = new StringBuilder();
        for (E aList : list) {
            String text = iJoin.getProperty(aList);
            if (TextUtils.isEmpty(text))
                continue;
            content.append(text).append(interpolation);
        }
        int end = content.lastIndexOf(interpolation);
        return content.substring(0, end == -1 ? 0 : end);
    }

    /**
     * 按指定字符拆分字符串
     *
     * @param content 原始数据
     * @param regex   拆分字符
     * @return 最终的拆分结果，如果原始数据为空，则返回null
     */
    public static List<String> split(String content, String regex) {
        if (content == null || content.length() == 0) return null;
        String[] strings = content.split(regex);
        return Arrays.asList(strings);
    }

    /**
     * 获取列表下全部数据，某整型属性的和
     *
     * @param iSum 指定求和使用的属性
     * @return 最终和
     */
    public static <T> int getDataIntSum(List<T> list, IIntSum<T> iSum) {
        if (list == null || list.size() == 0) return 0;
        int sum = 0;
        for (T aList : list) {
            Integer integer = iSum.getProperty(aList);
            sum += (integer == null ? 0 : integer);
        }
        return sum;
    }

    /**
     * 获取列表下全部数据，某浮点类型属性的和
     *
     * @param iSum 指定求和使用的属性
     * @return 最终和
     */
    public static <T> int getDataDoubleSum(List<T> list, IDoubleSum<T> iSum) {
        if (list == null || list.size() == 0) return 0;
        int sum = 0;
        for (T aList : list) {
            Double dob = iSum.getProperty(aList);
            sum += (dob == null ? 0 : dob);
        }
        return sum;
    }

    /**
     * 根据指定条件过滤符合条件的数据
     *
     * @param iWhere 指定的条件表达式
     * @return 符合条件的数据, 不会为null
     */
    public static <T> List<T> where(List<T> list, IWhere<T> iWhere) {
        List<T> lists = new ArrayList<T>();
        if (list == null || list.size() == 0) return lists;
        for (T t : list) {
            if (iWhere.getCondition(t)) {
                lists.add(t);
            }
        }
        return lists;
    }

    /**
     * 根据原始数据列表转换成目标数据列表
     */
    public static <T, S> List<S> convert(List<T> list, IConvert<T, S> iConvert) {
        List<S> lists = new ArrayList<S>();
        if (list == null || list.size() == 0) return lists;
        for (T t : list) {
            S s = iConvert.getEntity(t);
            if (s != null) {
                lists.add(s);
            }
        }
        return lists;
    }

    public interface IIntSum<T> {
        Integer getProperty(T t);
    }

    public interface IDoubleSum<T> {
        Double getProperty(T t);
    }

    public interface IJoin<E> {
        String getProperty(E e);
    }

    public interface IWhere<E> {
        boolean getCondition(E e);
    }

    public interface IConvert<T, S> {
        S getEntity(T e);
    }

}
